# Copyright 2024 DeepMind Technologies Limited
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================

"""Dict containing results and meta-info for codecs on the UVG dataset."""

import immutabledict

RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.01594833859347827,
            0.02268396719193247,
            0.033139908094155894,
            0.05459793865953716,
            0.08459428009726773,
            0.12762070219697697,
            0.25398065725859764,
            0.44254081146819296,
        ),
        'psnr': (
            32.925598689488005,
            33.96687752859933,
            35.02668489728655,
            36.327970777239116,
            37.44999258858817,
            38.36397443498884,
            39.704908643450054,
            40.794677189418245,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (HM 18.0, Random Access)': immutabledict.immutabledict({
        'bpp': (0.754, 0.1878, 0.073, 0.0324, 0.0155, 0.0075),
        'psnr': (41.515, 39.4299, 38.0631, 36.4091, 34.6332, 32.79),
        'meta': immutabledict.immutabledict({
            'source': 'Communication with HiNeRV authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.20067550237689696,
            0.1585183056905156,
            0.12094572271619523,
            0.09602879923014414,
            0.048752813346329194,
            0.02604843568589006,
            0.014397781647387005,
            0.007948939012186159,
        ),
        'psnr': (
            39.612552642822266,
            39.343265533447266,
            39.025550842285156,
            38.739532470703125,
            37.595733642578125,
            36.29216766357422,
            34.86935043334961,
            33.3802604675293,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.0146233484,
            0.03131311358,
            0.03639926326,
            0.04228131431,
            0.04917328591,
            0.05716917074,
            0.06695553075,
            0.07970082402,
            0.09619408436,
            0.1181599886,
            0.1475433606,
            0.1843980408,
            0.2346683853,
            0.2976021799,
            0.3765921948,
            0.4717144319,
        ),
        'psnr': (
            32.26268781,
            34.32666713,
            34.74231993,
            35.11978842,
            35.48612969,
            35.84851746,
            36.20992209,
            36.577288,
            36.9406519,
            37.29560333,
            37.65905021,
            38.0196382,
            38.38901985,
            38.77249507,
            39.16400642,
            39.57588169,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (
            0.01488571429,
            0.02974285714,
            0.05802857143,
            0.1154285714,
            0.2261571429,
        ),
        'psnr': (34.53182857, 36.01264286, 37.45017143, 38.60161429, 39.6261),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 87_287,
                'max': 1_277_840,
                'source': 'Paper and direct communication with authors. We '
                          ' report MACs for the S and XXL models asthe min and'
                          ' max, where the S model is used for the RD point'
                          ' with the lowest bpp and the XXL model is used for'
                          ' the point with the highest bpp. Note that the paper'
                          ' gives MACs per frame, so the number in the paper is'
                          ' divided by num_pixels_per_frame=1920*1080. Same'
                          ' goes for other NeRV baselines below.'
            }),
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.01379241719,
            0.02236251943,
            0.03499903985,
            0.05489411767,
            0.08854167145,
            0.1512379666,
            0.2679494834,
            0.493670691,
        ),
        'psnr': (
            32.48781465,
            33.93171086,
            35.26738949,
            36.43507358,
            37.51903957,
            38.49818091,
            39.37668041,
            40.42103526,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 5_336_375,
                'max': 5_336_375,
                'source': 'Communication with VCT authors.'
            }),
        }),
    }),
    'ELF-VC': immutabledict.immutabledict({
        'bpp': (
            0.01161056429,
            0.015798,
            0.02227867143,
            0.03234948571,
            0.04804898571,
            0.07333342857,
            0.1028811857,
            0.1705394429,
            0.2814992857,
            0.473687,
        ),
        'psnr': (
            31.54228571,
            32.816,
            33.98692857,
            35.08148571,
            36.07285714,
            37.00525714,
            37.60955714,
            38.5164,
            39.40165714,
            40.28675714,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2104.14335',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
    'DCVC': immutabledict.immutabledict({
        'bpp': (0.02709702142, 0.04098199165, 0.06370908664, 0.1038598493),
        'psnr': (34.0118812, 35.20922314, 36.35551458, 37.44416936),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2109.15047',
            'type': 'autoencoder',
            'data': 'multi',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 1_093_750,
                'max': 1_093_750,
                'source': 'Paper. Note that the paper gives MACs per frame, so'
                          ' the number in the paper is divided by'
                          ' num_pixels_per_frame=1920*1080.'
            }),
        }),
    }),
    'FVC': immutabledict.immutabledict({
        'bpp': (0.04496, 0.061964, 0.089331, 0.150682),
        'psnr': (34.854808, 36.041041, 37.062886, 38.029177),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2105.09600',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
    'RLVC': immutabledict.immutabledict({
        'bpp': (0.04005589, 0.060433392, 0.095095705, 0.168091311),
        'psnr': (34.03116539, 35.63045121, 36.80032917, 37.92631779),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2006.13560',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
    'Insta-SSF5': immutabledict.immutabledict({
        'bpp': (
            0.02131228404832558,
            0.031016738006034095,
            0.04463989529389885,
            0.06711116541318021,
            0.11051645240729678,
            0.18945935003977227,
            0.3389479573178224,
            0.5897115281554326,
        ),
        'psnr': (
            32.90446259903374,
            34.192829939439264,
            35.39011445609504,
            36.51618264918629,
            37.699480429393915,
            38.928345104416614,
            40.139516761695916,
            41.461936105668414,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Paper, from figure using plot digitizer.',
            'reference': 'https://arxiv.org/abs/2111.10302',
            'type': 'autoencoder',
            'data': 'multi',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 84_700,
                'max': 84_700,
                'source': 'Paper.'
            }),
        }),
    }),
    'Insta-SSF18': immutabledict.immutabledict({
        'bpp': (
            0.02183274597670713,
            0.030184581430226648,
            0.04325399052667749,
            0.06576156347657852,
            0.10659470650466019,
            0.1767439975614345,
            0.3208220788129425,
            0.5811206557255124,
        ),
        'psnr': (
            33.0385427877943,
            34.337487247248,
            35.5419375666903,
            36.6531789357379,
            37.8238248608485,
            38.87650176142861,
            40.17633578785367,
            41.56280522788889,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Paper, from figure using plot digitizer.',
            'reference': 'https://arxiv.org/abs/2111.10302',
            'type': 'autoencoder',
            'data': 'multi',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 285_800,
                'max': 285_800,
                'source': 'Paper.'
            }),
        }),
    }),
    'MIMT': immutabledict.immutabledict({
        'bpp': (
            0.0111386327753957,
            0.0247296961794620,
            0.0451780799748417,
            0.0884125075745942,
        ),
        'psnr': (
            35.45834134047365,
            36.48019642484780,
            37.52512505415275,
            38.45624546756446,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Paper, from figure using plot digitizer.',
            'reference': 'https://openreview.net/forum?id=j9m-mVnndbm',
            'type': 'autoencoder',
            'data': 'multi',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 2_130_111,
                'max': 2_130_111,
                'source': 'Paper. Note that the paper gives MACs per frame, so'
                          ' the number in the paper is divided by'
                          ' num_pixels_per_frame=1920*1080.'
            }),
        }),
    }),
    'FFNeRV': immutabledict.immutabledict({
        'bpp': (
            0.0182,
            0.0546,
            0.0890,
            0.131,
            0.180,
            0.239,
        ),
        'psnr': (
            32.71,
            35.55,
            36.76,
            37.64,
            38.33,
            38.91,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Paper, Table 11.',
            'reference': 'https://arxiv.org/abs/2212.12294',
            'type': 'neural-field',
            'data': 'single',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 109_953,
                # 'max': , The MACs for the largest FFNeRV model is unknown.
                'source': 'HiNeRV paper and direct communication with authors.'
            }),
        }),
    }),
    'HNeRV': immutabledict.immutabledict({
        'bpp': (
            0.015204,
            0.029544,
            0.057952,
            0.115287,
            0.233589,
        ),
        'psnr': (
            32.493094,
            33.682530,
            34.936854,
            36.146509,
            37.344033,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'HiNeRV paper, from figure using plot digitizer.',
            'reference': 'https://arxiv.org/abs/2304.02633',
            'type': 'neural-field',
            'data': 'single',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 109_471,
                'max': 121_518,
                'source': 'HiNeRV paper and direct communication with authors.'
            }),
        }),
    }),
    'NeRV': immutabledict.immutabledict({
        'bpp': (
            0.0142574,
            0.0283747,
            0.0563083,
            0.1121414,
            0.2285840,
        ),
        'psnr': (
            30.94369,
            32.74380,
            34.39044,
            35.97299,
            37.58784,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'HiNeRV paper, from figure using plot digitizer.',
            'reference': 'https://arxiv.org/abs/2110.13903',
            'type': 'neural-field',
            'data': 'single',
            'macs_per_pixel': immutabledict.immutabledict({
                'min': 110_918,
                'max': 1_369_381,
                'source': 'HiNeRV paper and direct communication with authors.'
            }),
        }),
    }),
})

BEAUTY_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.010050684601689378,
            0.012360346799444718,
            0.0160525635680339,
            0.024176362251940493,
            0.04204665634121436,
            0.10816917172245061,
            0.44460512317406636,
            0.9687660108630856,
        ),
        'psnr': (
            32.97476577758789,
            33.41041946411133,
            33.735130310058594,
            34.06508255004883,
            34.28904342651367,
            34.936195373535156,
            36.891178131103516,
            38.808494567871094,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.00115808899,
            0.002045235338,
            0.004185931082,
            0.008622524418,
            0.01707372685,
            0.01963138503,
            0.02282823429,
            0.02720118312,
            0.03277719262,
            0.04286167046,
            0.06097298097,
            0.09090237265,
            0.1411322982,
            0.212791538,
            0.2953929592,
            0.4242457432,
            0.568557504,
            0.7318548736,
            0.9237218886,
            1.132792348,
            1.36575218,
            1.612732798,
            1.848236664,
            2.093752348,
            2.420102854,
            2.700818798,
            2.961288716,
            3.264408079,
            3.585855589,
            3.863091795,
        ),
        'psnr': (
            27.71943351,
            29.47246252,
            31.16759862,
            32.48759541,
            33.34553796,
            33.49551226,
            33.60976501,
            33.71931496,
            33.79650331,
            33.88428776,
            33.99848445,
            34.13406045,
            34.33097542,
            34.59752119,
            34.88934776,
            35.29920303,
            35.74983008,
            36.23287155,
            36.84808734,
            37.49817733,
            38.0751921,
            38.83931803,
            39.73860651,
            40.50845013,
            41.42416667,
            42.26155318,
            42.96725086,
            43.89181215,
            44.75878028,
            45.52394545,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.38951927701632183,
            0.2698152128855387,
            0.1609583197037379,
            0.09711536794900893,
            0.026957638760407767,
            0.011783764126400153,
            0.006494900944332282,
            0.0036911007730911177,
        ),
        'psnr': (
            35.68302917480469,
            35.22509765625,
            34.779972076416016,
            34.51656723022461,
            34.157047271728516,
            33.8736572265625,
            33.50996017456055,
            33.02207946777344,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiements',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.013, 0.0261, 0.0512, 0.102, 0.2007),
        'psnr': (33.8697, 34.0719, 34.4058, 34.7496, 35.2415),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.006773124512,
            0.01032559702,
            0.01698156906,
            0.02752634825,
            0.06002688459,
            0.1738807083,
            0.4381607023,
            0.880919444,
            1.317586919,
        ),
        'psnr': (
            33.11996987,
            33.52744354,
            33.95336363,
            34.22732861,
            34.57344975,
            35.30066835,
            36.3060863,
            37.52835663,
            38.34498334,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})

BOSPHORUS_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.010261636331658034,
            0.014262584608028797,
            0.02033674122018662,
            0.032516769657377154,
            0.053004607123633224,
            0.07365888472801695,
            0.13820952924628122,
            0.20775837127002889,
        ),
        'psnr': (
            35.56731033325195,
            36.722042083740234,
            37.918617248535156,
            39.32243347167969,
            40.383018493652344,
            41.23855972290039,
            42.4293098449707,
            43.286441802978516,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.0008343042718,
            0.001714660496,
            0.003836143259,
            0.009130388356,
            0.02152948174,
            0.02582458204,
            0.03055843624,
            0.03638095422,
            0.04341466044,
            0.0514297647,
            0.06147609951,
            0.07331970807,
            0.08653865733,
            0.104015773,
            0.1248475632,
            0.1482838863,
            0.1805188592,
            0.2179416474,
            0.2580782527,
            0.3173425027,
            0.3952889729,
            0.4829078255,
            0.6012824914,
            0.7448861752,
            0.9055433772,
            1.123770672,
            1.368616829,
            1.605886528,
            1.869238893,
            2.137469989,
        ),
        'psnr': (
            26.536707,
            28.73245581,
            30.99237676,
            33.32069569,
            35.7464555,
            36.23765497,
            36.64962601,
            37.07786601,
            37.53228538,
            37.98341679,
            38.4314151,
            38.87185196,
            39.27645922,
            39.70117037,
            40.11207745,
            40.49807943,
            40.89999172,
            41.28415859,
            41.62588555,
            42.01105679,
            42.41012944,
            42.78538821,
            43.19873237,
            43.62355209,
            44.03526321,
            44.548304,
            45.13682831,
            45.71923576,
            46.40891167,
            47.14919687,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.10300439139207204,
            0.08751662194728851,
            0.07280706614255905,
            0.06035998582839966,
            0.030705722669760387,
            0.01610202545921008,
            0.008629179572065672,
            0.004685442391782999,
        ),
        'psnr': (
            42.07441711425781,
            41.82797622680664,
            41.520240783691406,
            41.184478759765625,
            39.81302261352539,
            38.286014556884766,
            36.62968826293945,
            34.9600944519043,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.0131, 0.0262, 0.0511, 0.1015, 0.1981),
        'psnr': (37.528, 39.3597, 41.1443, 42.4046, 43.2786),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.008083063907,
            0.01400428088,
            0.02186396273,
            0.03471155599,
            0.05598796235,
            0.0911476625,
            0.1488672805,
            0.2629245923,
            0.4540017018,
        ),
        'psnr': (
            33.4257788,
            35.00409921,
            36.61634987,
            38.0872574,
            39.51908215,
            40.72613692,
            41.64106805,
            42.80255104,
            43.53423058,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})

HONEYBEE_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.008884227795836827,
            0.010703726678912062,
            0.013055100256072668,
            0.017905752916703932,
            0.03134384720081774,
            0.041387882040968785,
            0.08882348972450321,
            0.19873188129470995,
        ),
        'psnr': (
            35.78207015991211,
            36.51614761352539,
            37.125831604003906,
            37.793296813964844,
            38.39179229736328,
            38.73643112182617,
            39.1976203918457,
            39.88926315307617,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.0005095678994,
            0.0008709362196,
            0.001165702168,
            0.00173688271,
            0.002886175412,
            0.003357278802,
            0.00394758876,
            0.004871862139,
            0.006415181356,
            0.009155780634,
            0.01374543468,
            0.02073265176,
            0.03137662688,
            0.04990305429,
            0.08087004254,
            0.124884439,
            0.1912531249,
            0.2879437499,
            0.4022170651,
            0.5491207248,
            0.7482397437,
            0.9767392742,
            1.232285153,
            1.515943435,
            1.783686576,
            2.045494961,
            2.335367916,
            2.625955344,
            2.912666231,
            3.213114315,
        ),
        'psnr': (
            25.57074781,
            28.61058567,
            30.89839249,
            32.69794377,
            34.69397952,
            35.0950594,
            35.45460131,
            35.80039801,
            36.16488822,
            36.51930178,
            36.85951452,
            37.18811294,
            37.48385852,
            37.76232751,
            38.03921218,
            38.31274329,
            38.60839153,
            38.93339238,
            39.27887907,
            39.67822761,
            40.17268768,
            40.71252451,
            41.28291988,
            41.93139857,
            42.62560951,
            43.34364831,
            44.15387168,
            44.97595412,
            45.75056946,
            46.56888957,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.09448584834734598,
            0.05754803200562795,
            0.03743688916166624,
            0.024163985500733058,
            0.012452983558177947,
            0.008166840225458145,
            0.0055668660129110014,
            0.0037865805253386496,
        ),
        'psnr': (
            39.09477996826172,
            38.931976318359375,
            38.799766540527344,
            38.65705871582031,
            37.909481048583984,
            36.98603439331055,
            35.67388153076172,
            34.00019454956055,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.0133, 0.0264, 0.0513, 0.102, 0.1993),
        'psnr': (38.7538, 39.2851, 39.6931, 40.0652, 40.3297),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.007522676374,
            0.01171856623,
            0.0179930696,
            0.02893514637,
            0.05057354084,
            0.09183864817,
            0.18163303,
            0.4173794461,
            0.8298205712,
        ),
        'psnr': (
            32.01360958,
            33.5961153,
            35.02271631,
            36.16000562,
            37.06709544,
            37.75912888,
            38.37801191,
            39.19155656,
            40.06754168,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})

JOCKEY_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.015441530968625253,
            0.021698799939864937,
            0.032144206794328056,
            0.055076323231332935,
            0.08609376446499178,
            0.12893884191289545,
            0.22348828334361315,
            0.3798738466886183,
        ),
        'psnr': (
            31.970964431762695,
            33.01723098754883,
            34.09822082519531,
            35.462181091308594,
            36.860538482666016,
            37.86589050292969,
            39.1264762878418,
            40.033348083496094,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.002144553757,
            0.003228176436,
            0.005865779324,
            0.01050169108,
            0.01849099151,
            0.02092896733,
            0.0237920139,
            0.0269897248,
            0.03047892232,
            0.03495958714,
            0.04056395316,
            0.04757737275,
            0.05689380149,
            0.06897680052,
            0.08668830366,
            0.1143778807,
            0.1522356033,
            0.2095516785,
            0.2916211225,
            0.3893928431,
            0.519836491,
            0.6963687503,
            0.8897322085,
            1.106680377,
            1.34827284,
            1.574361125,
            1.816264382,
            2.089161165,
            2.364820469,
            2.646204346,
        ),
        'psnr': (
            26.56680003,
            28.85431695,
            31.57704432,
            33.85167161,
            35.76778573,
            36.1679118,
            36.51799063,
            36.80207142,
            37.05944888,
            37.34013893,
            37.61232911,
            37.86711239,
            38.10978182,
            38.33565759,
            38.55596128,
            38.77836652,
            39.00015727,
            39.24414029,
            39.52348316,
            39.82573512,
            40.18422893,
            40.63625765,
            41.12582195,
            41.66679663,
            42.30003825,
            42.93839331,
            43.62006612,
            44.42031048,
            45.19175073,
            45.94948751,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.10632831086715062,
            0.07900716294844945,
            0.05870598668853442,
            0.0456767039000988,
            0.02338671570022901,
            0.013560281607011953,
            0.008439802005887032,
            0.005382053684443235,
        ),
        'psnr': (
            39.408294677734375,
            39.25790023803711,
            39.08727264404297,
            38.91731262207031,
            38.218360900878906,
            37.31998062133789,
            36.243839263916016,
            35.01506423950195,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.013, 0.0262, 0.0511, 0.1017, 0.1997),
        'psnr': (35.3858, 37.356, 38.5601, 39.1402, 39.8192),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.01265824927,
            0.01724256673,
            0.0252755631,
            0.03694204742,
            0.05480954959,
            0.08857055284,
            0.1637838964,
            0.3612923422,
            0.7418275879,
        ),
        'psnr': (
            34.82216901,
            35.96753832,
            37.04228984,
            37.86889215,
            38.57984511,
            39.16509113,
            39.74153934,
            40.59538232,
            41.67526291,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})

READYSETGO_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.03440686540610235,
            0.05015435066040178,
            0.07315845542567938,
            0.11821751421909237,
            0.1684759724206136,
            0.23755911035696045,
            0.364017710032446,
            0.523060373775661,
        ),
        'psnr': (
            29.709619522094727,
            31.278114318847656,
            32.8843994140625,
            34.93806076049805,
            36.799190521240234,
            38.19867706298828,
            40.0916748046875,
            41.219112396240234,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.003950237915,
            0.006312789344,
            0.0127695795,
            0.02469793598,
            0.04598749355,
            0.05221044245,
            0.05929072784,
            0.06732492922,
            0.07648262604,
            0.08691194049,
            0.09904867542,
            0.1132673226,
            0.1298465151,
            0.1495908244,
            0.1732154837,
            0.2015224729,
            0.2365232186,
            0.2791537808,
            0.3305975047,
            0.3964339248,
            0.4816643066,
            0.5843911973,
            0.7082827158,
            0.8578079157,
            1.032759498,
            1.235032599,
            1.462822314,
            1.700558643,
            1.949255509,
            2.2098229,
        ),
        'psnr': (
            23.0987466,
            25.64633754,
            28.47798426,
            31.14627343,
            33.77426844,
            34.30003099,
            34.79861195,
            35.29925083,
            35.78840764,
            36.27561028,
            36.77281167,
            37.25967199,
            37.73330938,
            38.20722129,
            38.66773889,
            39.11738281,
            39.56415111,
            39.99770695,
            40.41803953,
            40.8449792,
            41.28319174,
            41.72939077,
            42.195389,
            42.6816525,
            43.18725021,
            43.73674189,
            44.34451818,
            44.99114412,
            45.67585904,
            46.42800593,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.1542073380947113,
            0.13621246794859568,
            0.11712108463048936,
            0.1023658819993337,
            0.06205499569574992,
            0.03711595296859741,
            0.022869778846700987,
            0.01415236624578635,
        ),
        'psnr': (
            41.02678298950195,
            40.74290084838867,
            40.36465835571289,
            39.98554611206055,
            38.37117004394531,
            36.49515151977539,
            34.530426025390625,
            32.584964752197266,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.0131, 0.0263, 0.0513, 0.1018, 0.1991),
        'psnr': (30.6287, 33.618, 36.5524, 38.6495, 40.1372),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.02402299707,
            0.03631580219,
            0.05333551907,
            0.08000657424,
            0.1198372359,
            0.1793753442,
            0.2708534393,
            0.4256286119,
            0.6648697216,
        ),
        'psnr': (
            31.9923192,
            33.74235851,
            35.305001,
            36.75126615,
            38.10168401,
            39.25668413,
            40.19757743,
            41.16761355,
            41.90035157,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})

SHAKENDRY_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.01135890802349119,
            0.016844887878202524,
            0.026078339738887735,
            0.045114195866820715,
            0.075923013399976,
            0.11065860791131854,
            0.20995707732314864,
            0.38954471551502745,
        ),
        'psnr': (
            32.94499206542969,
            33.900936126708984,
            34.94967269897461,
            36.1951904296875,
            37.218631744384766,
            37.9559211730957,
            38.823490142822266,
            39.84563446044922,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.001033719138,
            0.001948521099,
            0.00464664351,
            0.01479594909,
            0.04015925921,
            0.04799014897,
            0.05728319188,
            0.06817226092,
            0.08061746432,
            0.09477559167,
            0.1123131558,
            0.1335584105,
            0.1602629886,
            0.1959922967,
            0.2435971326,
            0.3051134521,
            0.3862152649,
            0.4899396855,
            0.6181120775,
            0.7788256812,
            0.9727831529,
            1.196908189,
            1.446941487,
            1.70632073,
            1.966188711,
            2.239307128,
            2.521000458,
            2.802257084,
            3.094128679,
            3.393421698,
        ),
        'psnr': (
            25.03436941,
            27.07747271,
            29.20936875,
            31.31587404,
            33.39425421,
            33.8123977,
            34.2093337,
            34.61706036,
            35.02249367,
            35.41452788,
            35.82145807,
            36.21700073,
            36.59105526,
            36.9643424,
            37.33048116,
            37.69481889,
            38.08114404,
            38.4796585,
            38.90815231,
            39.39005464,
            39.91862972,
            40.4751694,
            41.10382688,
            41.78952534,
            42.50284285,
            43.26798463,
            44.06102814,
            44.83709984,
            45.64741622,
            46.48186788,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.2656276327371597,
            0.22025009155273437,
            0.17864350348711014,
            0.14998009393612544,
            0.0789833195010821,
            0.03947412545482318,
            0.019374691198269525,
            0.009111471138894559,
        ),
        'psnr': (
            38.737823486328125,
            38.50117492675781,
            38.21590805053711,
            37.960994720458984,
            36.73723602294922,
            35.324405670166016,
            33.839420318603516,
            32.37446975708008,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.0255, 0.0508, 0.0991, 0.1971, 0.3867),
        'psnr': (35.3189, 36.4113, 37.6671, 38.7703, 39.72),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'NIRVANA': immutabledict.immutabledict({
        'bpp': (0.24, 0.76),
        'psnr': (34.78, 37.82),
        'meta': immutabledict.immutabledict({
            'source': 'Paper',
            'reference': 'https://arxiv.org/abs/2212.14593',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'NeRV': immutabledict.immutabledict({
        'bpp': (0.49, 1.61),
        'psnr': (36.09, 39.68),
        'meta': immutabledict.immutabledict({
            'source': 'Paper',
            'reference': 'https://arxiv.org/abs/2110.13903',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'NVP': immutabledict.immutabledict({
        'bpp': (0.12, 0.24, 0.26, 0.32, 0.48),
        'psnr': (34.2, 36.7, 37.0, 37.6, 37.9),
        'meta': immutabledict.immutabledict({
            'source': 'Paper',
            'reference': 'https://arxiv.org/abs/2210.06823',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.015113392996912202,
            0.027932165876651805,
            0.04693012879540523,
            0.0782298539703091,
            0.12881038131813208,
            0.2103605013092359,
            0.34502344762285553,
            0.613787052333355,
            1.0043578618764877,
        ),
        'psnr': (
            30.42513146718343,
            32.22830441157023,
            33.786084721883135,
            35.22413214365641,
            36.528455340067545,
            37.668508783976236,
            38.68867291768392,
            39.83146622975667,
            40.90169626871745,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})

YACHTRIDE_RESULTS = immutabledict.immutabledict({
    'C3 (Adaptive)': immutabledict.immutabledict({
        'bpp': (
            0.02123451702694486,
            0.03276307377867246,
            0.051153949655902885,
            0.08917865247349255,
            0.13527209972962737,
            0.192972416706228,
            0.30876338796612496,
            0.4300504808702196,
        ),
        'psnr': (
            31.529468536376953,
            32.92325210571289,
            34.47492218017578,
            36.51955032348633,
            38.207733154296875,
            39.616146087646484,
            41.374610900878906,
            42.480445861816406,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://arxiv.org/abs/2312.02753',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'HEVC (medium, no bframes)': immutabledict.immutabledict({
        'bpp': (
            0.001742097483,
            0.004395724017,
            0.01276992026,
            0.03287806714,
            0.07306466678,
            0.08485203817,
            0.09826900727,
            0.113272087,
            0.1299981481,
            0.1485943801,
            0.1697854686,
            0.1940007522,
            0.2210690329,
            0.2515332369,
            0.2861748009,
            0.3242508228,
            0.3679116843,
            0.4197599478,
            0.4776531119,
            0.5449752645,
            0.6306665444,
            0.7306821639,
            0.846119361,
            0.9879103577,
            1.149744091,
            1.339368878,
            1.570364916,
            1.80603628,
            2.052282584,
            2.315467146,
        ),
        'psnr': (
            23.82429118,
            25.92890974,
            28.48737774,
            31.01876073,
            33.56438855,
            34.08767237,
            34.59859034,
            35.08694625,
            35.57559509,
            36.05217117,
            36.54500305,
            37.04675286,
            37.54378369,
            38.04511117,
            38.5426487,
            39.02254495,
            39.50379976,
            39.97611668,
            40.42864489,
            40.87631161,
            41.33413085,
            41.79235547,
            42.2713663,
            42.7766785,
            43.28029894,
            43.80543965,
            44.39905255,
            45.02857329,
            45.69482299,
            46.42860187,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://www.itu.int/rec/T-REC-H.265',
            'type': 'classical',
        }),
    }),
    'VTM (17.0, Random Access)': immutabledict.immutabledict({
        'bpp': (
            0.29155571818351744,
            0.2592785505453746,
            0.2209472091992696,
            0.19253957549730938,
            0.1067283175388972,
            0.05613605995972951,
            0.029409252951542536,
            0.014833558325966199,
        ),
        'psnr': (
            41.26272964477539,
            40.915828704833984,
            40.41105270385742,
            39.95475387573242,
            37.96383285522461,
            35.75994110107422,
            33.65823745727539,
            31.70497703552246,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Our experiments',
            'reference': 'https://github.com/fraunhoferhhi/vvenc',
            'type': 'classical',
            'notes': (
                'qp=(17, 18, 19, 20, 24, 28, 32, 36), with default settings in '
                'internal libraries for running VTM.'
            ),
        }),
    }),
    'HiNeRV': immutabledict.immutabledict({
        'bpp': (0.0132, 0.0262, 0.0511, 0.1019, 0.1995),
        'psnr': (30.2379, 31.9865, 34.1284, 36.4319, 38.8565),
        'meta': immutabledict.immutabledict({
            'source': 'https://github.com/hmkx/HiNeRV/tree/main/results/uvg_results.xlsx',
            'reference': 'https://arxiv.org/abs/2306.09818',
            'type': 'neural-field',
            'data': 'single',
        }),
    }),
    'VCT': immutabledict.immutabledict({
        'bpp': (
            0.0223734162,
            0.03899865706,
            0.06261346662,
            0.09790729747,
            0.1497461455,
            0.2234923486,
            0.3273245878,
            0.4937633485,
            0.7220331574,
        ),
        'psnr': (
            31.61572461,
            33.45611671,
            35.14592105,
            36.72663301,
            38.26366518,
            39.61104815,
            40.68380695,
            41.83032049,
            42.5661947,
        ),
        'meta': immutabledict.immutabledict({
            'source': 'Obtained by communication with VCT authors',
            'reference': 'https://arxiv.org/abs/2206.07307',
            'type': 'autoencoder',
            'data': 'multi',
        }),
    }),
})
